Convert.ToBase64String Method (System)

#Convert.ToBase64String Method (System) | 来源: 网络整理| 查看: 265

Converts a subset of an array of 8-bit unsigned integers to its equivalent string representation that is encoded with base-64 digits. Parameters specify the subset as an offset in the input array, the number of elements in the array to convert, and whether to insert line breaks in the return value.

public: static System::String ^ ToBase64String(cli::array ^ inArray, int offset, int length, Base64FormattingOptions options); public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options); [System.Runtime.InteropServices.ComVisible(false)] public static string ToBase64String (byte[] inArray, int offset, int length, Base64FormattingOptions options); static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> string [] static member ToBase64String : byte[] * int * int * Base64FormattingOptions -> string Public Shared Function ToBase64String (inArray As Byte(), offset As Integer, length As Integer, options As Base64FormattingOptions) As String Parameters inArray Byte[]

An array of 8-bit unsigned integers.

offset Int32

An offset in inArray.

length Int32

The number of elements of inArray to convert.

options Base64FormattingOptions

InsertLineBreaks to insert a line break every 76 characters, or None to not insert line breaks.

Returns String

The string representation in base 64 of length elements of inArray, starting at position offset.

Attributes ComVisibleAttribute Exceptions ArgumentNullException

inArray is null.

ArgumentOutOfRangeException

offset or length is negative.

-or-

offset plus length is greater than the length of inArray.

ArgumentException

options is not a valid Base64FormattingOptions value.

Examples

The following example demonstrates the ToBase64String method. The input is divided into groups of three bytes (24 bits) each. Consequently, each group consists of four 6-bit numbers where each number ranges from decimal 0 to 63. In this example, there are 85 3-byte groups with one byte remaining. The first group consists of the hexadecimal values 00, 01, and 02, which yield four 6-bit values equal to decimal 0, 0, 4, and 2. Those four values correspond to the base-64 digits "A", "A", "E", and "C" at the beginning of the output.

If an integral number of 3-byte groups does not exist, the remaining bytes are effectively padded with zeros to form a complete group. In this example, the value of the last byte is hexadecimal FF. The first 6 bits are equal to decimal 63, which corresponds to the base-64 digit "/" at the end of the output, and the next 2 bits are padded with zeros to yield decimal 48, which corresponds to the base-64 digit, "w". The last two 6-bit values are padding and correspond to the valueless padding character, "=".

// This example demonstrates the Convert.ToBase64String() and // Convert.FromBase64String() methods using namespace System; bool ArraysAreEqual( array^a1, array^a2 ); int main() { array^inArray = gcnew array(256); array^outArray = gcnew array(256); String^ s2; String^ s3; String^ step1 = "1) The input is a byte array (inArray) of arbitrary data."; String^ step2 = "2) Convert a subarray of the input data array to a base 64 string."; String^ step3 = "3) Convert the entire input data array to a base 64 string."; String^ step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}"; String^ step5 = "5) Convert the base 64 string to an output byte array (outArray)."; String^ step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}"; int x; String^ nl = Environment::NewLine; String^ ruler1a = " 1 2 3 4"; String^ ruler2a = "1234567890123456789012345678901234567890"; String^ ruler3a = "----+----+----+----+----+----+----+----+"; String^ ruler1b = " 5 6 7 "; String^ ruler2b = "123456789012345678901234567890123456"; String^ ruler3b = "----+----+----+----+----+----+----+-"; String^ ruler = String::Concat( ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b, nl ); // 1) Display an arbitrary array of input data (inArray). The data could be // derived from user input, a file, an algorithm, etc. Console::WriteLine( step1 ); Console::WriteLine(); for ( x = 0; x < inArray->Length; x++ ) { inArray[ x ] = (Byte)x; Console::Write( "{0:X2} ", inArray[ x ] ); if ( ((x + 1) % 20) == 0 ) Console::WriteLine(); } Console::Write( "{0}{0}", nl ); // 2) Convert a subarray of the input data to a base64 string. In this case, // the subarray is the entire input data array. New lines (CRLF) are inserted. Console::WriteLine( step2 ); s2 = Convert::ToBase64String( inArray, 0, inArray->Length, Base64FormattingOptions::InsertLineBreaks ); Console::WriteLine( "{0}{1}{2}{3}", nl, ruler, s2, nl ); // 3) Convert the input data to a base64 string. In this case, the entire // input data array is converted by default. New lines (CRLF) are inserted. Console::WriteLine( step3 ); s3 = Convert::ToBase64String( inArray, Base64FormattingOptions::InsertLineBreaks ); // 4) Test whether the methods in steps 2 and 3 produce the same result. Console::WriteLine( step4, s2->Equals( s3 ) ); // 5) Convert the base 64 string to an output array (outArray). Console::WriteLine( step5 ); outArray = Convert::FromBase64String( s2 ); // 6) Is outArray equal to inArray? Console::WriteLine( step6, ArraysAreEqual( inArray, outArray ) ); } bool ArraysAreEqual( array^a1, array^a2 ) { if ( a1->Length != a2->Length ) return false; for ( int i = 0; i < a1->Length; i++ ) if ( a1[ i ] != a2[ i ] ) return false; return true; } /* This example produces the following results: 1) The input is a byte array (inArray) of arbitrary data. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF 2) Convert a subarray of the input data array to a base 64 string. 1 2 3 4 5 6 7 1234567890123456789012345678901234567890123456789012345678901234567890123456 ----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+- AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4 OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj 5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== 3) Convert the entire input data array to a base 64 string. 4) The two methods in steps 2 and 3 produce the same result: True 5) Convert the base 64 string to an output byte array (outArray). 6) The input and output arrays, inArray and outArray, are equal: True */ // This example demonstrates the Convert.ToBase64String() and // Convert.FromBase64String() methods using System; class Sample { public static void Main() { byte[] inArray = new byte[256]; byte[] outArray = new byte[256]; string s2; string s3; string step1 = "1) The input is a byte array (inArray) of arbitrary data."; string step2 = "2) Convert a subarray of the input data array to a base 64 string."; string step3 = "3) Convert the entire input data array to a base 64 string."; string step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}"; string step5 = "5) Convert the base 64 string to an output byte array (outArray)."; string step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}"; int x; string nl = Environment.NewLine; string ruler1a = " 1 2 3 4"; string ruler2a = "1234567890123456789012345678901234567890"; string ruler3a = "----+----+----+----+----+----+----+----+"; string ruler1b = " 5 6 7 "; string ruler2b = "123456789012345678901234567890123456"; string ruler3b = "----+----+----+----+----+----+----+-"; string ruler = String.Concat(ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b, nl); // 1) Display an arbitrary array of input data (inArray). The data could be // derived from user input, a file, an algorithm, etc. Console.WriteLine(step1); Console.WriteLine(); for (x = 0; x < inArray.Length; x++) { inArray[x] = (byte)x; Console.Write("{0:X2} ", inArray[x]); if (((x+1)%20) == 0) Console.WriteLine(); } Console.Write("{0}{0}", nl); // 2) Convert a subarray of the input data to a base64 string. In this case, // the subarray is the entire input data array. New lines (CRLF) are inserted. Console.WriteLine(step2); s2 = Convert.ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.InsertLineBreaks); Console.WriteLine("{0}{1}{2}{3}", nl, ruler, s2, nl); // 3) Convert the input data to a base64 string. In this case, the entire // input data array is converted by default. New lines (CRLF) are inserted. Console.WriteLine(step3); s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks); // 4) Test whether the methods in steps 2 and 3 produce the same result. Console.WriteLine(step4, s2.Equals(s3)); // 5) Convert the base 64 string to an output array (outArray). Console.WriteLine(step5); outArray = Convert.FromBase64String(s2); // 6) Is outArray equal to inArray? Console.WriteLine(step6, ArraysAreEqual(inArray, outArray)); } public static bool ArraysAreEqual(byte[] a1, byte[] a2) { if (a1.Length != a2.Length) return false; for (int i = 0; i < a1.Length; i++) if (a1[i] != a2[i]) return false; return true; } } /* This example produces the following results: 1) The input is a byte array (inArray) of arbitrary data. 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF 2) Convert a subarray of the input data array to a base 64 string. 1 2 3 4 5 6 7 1234567890123456789012345678901234567890123456789012345678901234567890123456 ----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+- AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4 OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj 5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== 3) Convert the entire input data array to a base 64 string. 4) The two methods in steps 2 and 3 produce the same result: True 5) Convert the base 64 string to an output byte array (outArray). 6) The input and output arrays, inArray and outArray, are equal: True */ // This example demonstrates the Convert.ToBase64String() and // Convert.FromBase64String() methods open System let arraysAreEqual (a1: byte[]) (a2: byte[]) = a1.Length = a2.Length && Array.forall2 (=) a1 a2 let step1 = "1) The input is a byte array (inArray) of arbitrary data." let step2 = "2) Convert a subarray of the input data array to a base 64 string." let step3 = "3) Convert the entire input data array to a base 64 string." let step4 = "4) The two methods in steps 2 and 3 produce the same result: {0}" let step5 = "5) Convert the base 64 string to an output byte array (outArray)." let step6 = "6) The input and output arrays, inArray and outArray, are equal: {0}" let nl = Environment.NewLine let ruler = $" 1 2 3 4 5 6 7 {nl}" + $"1234567890123456789012345678901234567890123456789012345678901234567890123456{nl}" + $"----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+-{nl}" // 1) Display an arbitrary array of input data (inArray). The data could be // derived from user input, a file, an algorithm, etc. printfn $"{step1}\n" let inArray = [| for i = 0 to 255 do printf $"{i:X2} " if (i + 1) % 20 = 0 then printfn "" byte i |] printf $"{nl}{nl}" // 2) Convert a subarray of the input data to a base64 string. In this case, // the subarray is the entire input data array. New lines (CRLF) are inserted. printfn $"{step2}" let s2 = Convert.ToBase64String(inArray, 0, inArray.Length, Base64FormattingOptions.InsertLineBreaks) printfn $"{nl}{ruler}{s2}{nl}" // 3) Convert the input data to a base64 string. In this case, the entire // input data array is converted by default. New lines (CRLF) are inserted. printfn $"{step3}" let s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks) // 4) Test whether the methods in steps 2 and 3 produce the same result. printfn $"{step4} {s2.Equals s3}" // 5) Convert the base 64 string to an output array (outArray). printfn $"{step5}" let outArray = Convert.FromBase64String s2 // 6) Is outArray equal to inArray? printfn $"{step6} {arraysAreEqual inArray outArray}" // This example produces the following results: // 1) The input is a byte array (inArray) of arbitrary data. // // 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 // 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 // 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B // 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F // 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 // 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 // 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B // 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F // A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 // B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 // C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB // DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF // // 2) Convert a subarray of the input data array to a base 64 string. // // 1 2 3 4 5 6 7 // 1234567890123456789012345678901234567890123456789012345678901234567890123456 // ----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+- // AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4 // OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx // cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq // q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj // 5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w= // // 3) Convert the entire input data array to a base 64 string. // 4) The two methods in steps 2 and 3 produce the same result: True // 5) Convert the base 64 string to an output byte array (outArray). // 6) The input and output arrays, inArray and outArray, are equal: True ' This example demonstrates the Convert.ToBase64String() and ' Convert.FromBase64String() methods Class Sample Public Shared Sub Main() Dim inArray(255) As Byte Dim outArray(255) As Byte Dim s2 As String Dim s3 As String Dim step1 As String = "1) The input is a byte array (inArray) of arbitrary data." Dim step2 As String = "2) Convert a subarray of the input data array to a base 64 string." Dim step3 As String = "3) Convert the entire input data array to a base 64 string." Dim step4 As String = "4) The two methods in steps 2 and 3 produce the same result: {0}" Dim step5 As String = "5) Convert the base 64 string to an output byte array (outArray)." Dim step6 As String = "6) The input and output arrays, inArray and outArray, are equal: {0}" Dim x As Integer Dim nl As String = Environment.NewLine Dim ruler1a As String = " 1 2 3 4" Dim ruler2a As String = "1234567890123456789012345678901234567890" Dim ruler3a As String = "----+----+----+----+----+----+----+----+" Dim ruler1b As String = " 5 6 7 " Dim ruler2b As String = "123456789012345678901234567890123456" Dim ruler3b As String = "----+----+----+----+----+----+----+-" Dim ruler As String = [String].Concat(ruler1a, ruler1b, nl, ruler2a, ruler2b, nl, ruler3a, ruler3b, nl) ' 1) Display an arbitrary array of input data (inArray). The data could be ' derived from user input, a file, an algorithm, etc. Console.WriteLine(step1) Console.WriteLine() For x = 0 To inArray.Length - 1 inArray(x) = CByte(x) Console.Write("{0:X2} ", inArray(x)) If (x + 1) Mod 20 = 0 Then Console.WriteLine() End If Next x Console.Write("{0}{0}", nl) ' 2) Convert a subarray of the input data to a base64 string. In this case, ' the subarray is the entire input data array. New lines (CRLF) are inserted. Console.WriteLine(step2) s2 = Convert.ToBase64String(inArray, 0, inArray.Length, _ Base64FormattingOptions.InsertLineBreaks) Console.WriteLine("{0}{1}{2}{3}", nl, ruler, s2, nl) ' 3) Convert the input data to a base64 string. In this case, the entire ' input data array is converted by default. New lines (CRLF) are inserted. Console.WriteLine(step3) s3 = Convert.ToBase64String(inArray, Base64FormattingOptions.InsertLineBreaks) ' 4) Test whether the methods in steps 2 and 3 produce the same result. Console.WriteLine(step4, s2.Equals(s3)) ' 5) Convert the base 64 string to an output array (outArray). Console.WriteLine(step5) outArray = Convert.FromBase64String(s2) ' 6) Is outArray equal to inArray? Console.WriteLine(step6, ArraysAreEqual(inArray, outArray)) End Sub Public Shared Function ArraysAreEqual(a1() As Byte, a2() As Byte) As Boolean If a1.Length a2.Length Then Return False End If Dim i As Integer For i = 0 To a1.Length - 1 If a1(i) a2(i) Then Return False End If Next i Return True End Function 'ArraysAreEqual End Class ' 'This example produces the following results: ' '1) The input is a byte array (inArray) of arbitrary data. ' '00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 '14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 '28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B '3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F '50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 '64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 '78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B '8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F 'A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF B0 B1 B2 B3 'B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF C0 C1 C2 C3 C4 C5 C6 C7 'C8 C9 CA CB CC CD CE CF D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB 'DC DD DE DF E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF 'F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF ' '2) Convert a subarray of the input data array to a base 64 string. ' ' 1 2 3 4 5 6 7 '1234567890123456789012345678901234567890123456789012345678901234567890123456 '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----+- 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4 'OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3Bx 'cnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmq 'q6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj '5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w== ' '3) Convert the entire input data array to a base 64 string. '4) The two methods in steps 2 and 3 produce the same result: True '5) Convert the base 64 string to an output byte array (outArray). '6) The input and output arrays, inArray and outArray, are equal: True ' Remarks

The elements of the inArray parameter are taken as a numeric value and converted to a string representation in base 64.

The base-64 digits in ascending order from zero are the uppercase characters "A" to "Z", the lowercase characters "a" to "z", the numerals "0" to "9", and the symbols "+" and "/". The valueless character "=" is used for trailing padding.

The offset and length parameters are 32-bit signed numbers. The offset parameter is zero-based.

Important

The ToBase64String method is designed to process a single byte array that contains all the data to be encoded. To encode data from a stream, use the System.Security.Cryptography.ToBase64Transform class.

If the options parameter is set to InsertLineBreaks and the output of the conversion is longer than 76 characters, a line break is inserted every 76 characters. A line break is defined as a carriage return character (U+000D) followed by a line feed character (U+000A). For more information, see RFC 2045, "Multipurpose Internet Mail Extensions", at https://www.rfc-editor.org/.

See also FromBase64String(String) ToBase64Transform Applies to

【本文地址】

公司简介

联系我们